Lab 1: NumPy exercises¶

This ungraded assignment is composed of 26 NumPy exercises divided in three difficulty levels: beginner, intermediate, and advanced. In order to understand and solve the exercises, and more generally to gain the maximum benefit from this assignment, it is highly recommended that you read Chapter 1 in the course notes available on Blackboard.

IMPORTANT: Please refer to Chapter 1 as you work through this assignment.

Instructions¶

• Download a copy of this notebook from Blackboard.

• Run jupyter notebook and open the .ipynb file.

  • Keep the notebook inside the folder it was downloaded with. This folder contains all the dependencies needed for the notebook to work properly.

• Work alone or with a partner to solve the quizzes.

  • You are supposed to fill in or modify the code marked with the comment # YOUR CODE HERE
  • You can check your answers by running the tests provided at the end of each quiz

Contents¶

• Beginner level

• Intermediate level

• Advanced level

Required packages¶

For this assignment, you need to import the following packages.

• Numpy - The fundamental package for scientific computing with Python.

Part 1. Beginner level¶

Quiz 1.1¶

Create a vector of length 5, filled with zeros.

Hint: np.zeros()

Quiz 1.2¶

Create a matrix with 8 rows and 4 columns, filled with one.

Hint: np.ones()

Quiz 1.3¶

Get the number of rows and columns of a matrix.

Hint: .shape

Quiz 1.4¶

Propose three different ways to reshape an array into a vector (1d array).

Hints:

• .reshape()
• .ravel()
• .flatten()

Quiz 1.5¶

Given an array x, compute the following expression:

$$\log\left(\sum_{i=0}^{N-1} \exp(x_i) \right).$$

Hint:

• $\exp(\cdot)$ denotes the exponential, which can be computed in numpy with the function np.exp().
• $\sum_i \cdot$ denotes a summation, which can be computed in numpy with the function np.sum().
• $\log(\cdot)$ denotes the logarithm, which can be computed in numpy with the function np.log().

Quiz 1.6¶

Find the minimum and maximum values of a vector.

Hint:

• .min()
• .max()

Quiz 1.7¶

Compute the mean value of a matrix, of its rows, and of its columns.

Hint:

• .mean()

Quiz 1.8¶

Swap (in-place) the 2nd and 4th element of a vector.

Remark: Single indexing extracts one element from an array. In Python, single values are always copied when assigned to a variable.

Quiz 1.9¶

Given a matrix, extract the elements indicated in the figure below.

Hint: Recall that you can extract a contiguous part of a matrix via the slicing notation:

matrix[start_row : stop_row : step_row , start_col : stop_col : step_col]

You can omit any of the slicing indices. For example, these are valid slicing: start:stop, start:, :stop, :, ::step.

Part 2. Intermediate level¶

Quiz 2.1¶

Create a vector of size 10 filled with zero, and set the first and last elements to 1.

Remark: The solution can take more than one line of code.

Quiz 2.2¶

Create a vector of size 20 with an alternating pattern of 0 and 1.

Expected output: [0, 1, 0, 1, 0, 1, ..., 0, 1]

Quiz 2.3¶

Swap the first half of a vector with its last half.

Example: [1,2,3, 4,5,6] --> [4,5,6, 1,2,3]

Hints:

• The size of a vector is given by the attribute .size or .shape[0].
• Use the integer division n//2 to compute the length of half a vector.
• The function np.concatenate() merges a copy of the input vectors into a new array.

Quiz 2.4¶

Reshape an array of n elements into a matrix with n/2 rows and 2 columns.

Hint: .reshape()

Quiz 2.5¶

Given a vector with an even number of elements, compute the sum of two consecutive elements.

• Expected result: Vector holding the sum of 1st and 2nd elements, then the sum of 3rd and 4th elements, and so on.
• Example: [1, 2, 3, 4, 5, 6] --> [3, 7, 11]

Hint: Reshape the vector into a matrix with n/2 rows and 2 columns.

Quiz 2.6¶

Given a matrix with an even number of rows, compute the sum of two consecutive rows.

• Expected result: Vector holding the sum of elements on 1st and 2nd rows, the sum of elements on 3rd and 4th rows, and so on.

Hint: Reshape the matrix so as to align the rows that must be summed together.

Quiz 2.7¶

Replace the minimum value of a matrix by -10.

Hint: You can reshape the matrix into a vector, get the position of the minimum element with .argmin(), and modify the minimum value.

Quiz 2.8¶

Divide each row of a matrix by its maximum value, and put the result in a new matrix. Exploit broadcasting to avoid loops!

Hint: Remember what the argument keepdims does in the function np.max().

Quiz 2.9¶

Compute the following expression:

$${\sf sigmoid}({\bf w}^\top {\bf x}) = \frac{1}{1+e^{-(w_0 + w_1 x_1 + \dots + w_Q x_Q)}}$$

where

$${\bf w} = \begin{bmatrix}w_0\\w_1\\\vdots\\w_Q\end{bmatrix} \in \mathbb{R}^{Q+1} \qquad\qquad {\bf x} = \begin{bmatrix}\vphantom{1}\\x_1\\\vdots\\x_Q\end{bmatrix} \in \mathbb{R}^{Q}$$

with the convention $x_0=1$.

Hint: Note that the vectors don't have the same size:

• w - vector of shape (Q+1,)
• x - vector of shape (Q,).

To get around this, you can proceed as follows:

• Slice w so as to extract the elements w[1], ..., w[Q].
• Compute the scalar product between x and the above elements.
• Add w[0] to the final result.

Part 3. Advanced level (optional)¶

Quiz 3.1¶

Create a 8x8 matrix and fill it with a checkerboard pattern.

Expected output:

[[0 1 0 1 0 1 0 1] [1 0 1 0 1 0 1 0] [0 1 0 1 0 1 0 1] [1 0 1 0 1 0 1 0] [0 1 0 1 0 1 0 1] [1 0 1 0 1 0 1 0] [0 1 0 1 0 1 0 1] [1 0 1 0 1 0 1 0]]

Quiz 3.2¶

Swap (in-place) the 2nd and 4th column of a matrix.

Recall when data is shared or copied:

• No copy - A simple assignment produces an alias of the original array.
• Shared data - Slicing creates a view of the original array.
• Copied data - The method .copy() makes a copy of the original array.

Quiz 3.3¶

Find the element in a vector nearest to the value 1.

Hint: Given the vector x, compute the absolute values of x-1, and then find the index i of the minimum element.

• np.abs()
• np.argmin()

Example: step-by-step

• Consider the vector x = [5, -1, 3, 1.2, 8, 0]. What is the element in x nearest to the value 1?
• The operation x-1 results in the vector [4, -2, 2, 0.2, 7, -1].
• The absolute value of x-1 is thus [4, 2, 2, 0.2, 7, 1].
• What is the minimum element of this vector? Take notice of its position. It is the same as the element you are looking for!

Quiz 3.4¶

Given a matrix with an even number of columns, compute the sum of two consecutive columns.

• Expected result: Vector holding the sum of elements on 1st and 2nd columns, the sum of elements on 3rd and 4th columns, and so on.

Hint: Recall that a matrix is stored in row-major order, so you need to come up with a creative way of reshaping the matrix.

Quiz 3.5¶

• axis=None - sum over all the elements
• axis=0 - sum over the columns
• axis=1 - sum over the rows.

Implement a function that computes the following expression:

$${\sf softmax}({\bf x}) = \begin{bmatrix} \dfrac{e^{x_0}}{\sum_{j=0}^{N-1} e^{x_j}}\\ \vdots \\ \dfrac{e^{x_{N-1}}}{\sum_{j=0}^{N-1} e^{x_j}} \end{bmatrix}.$$

When the input is a matrix, the function must operate according to an input parameter axis:

Hint: In the skeleton function given below, print the shapes of intermediate variables x_exp, x_sum and s to help you with broadcasting.

• The shape of x_sum must be (1,1), (1,3) or (2,1) depending on the input parameter axis.

• The shape of x_exp and s must always be (2,3).

• Then, the division x_exp/x_sum will work due to broadcasting.

Quiz 3.6¶

Implement a function that computes the following expression:

$$J({\bf w}) = \sum_{n=1}^N \big(y^{(n)} - {\bf w}^\top {\bf x}^{(n)}\big)^2,$$

where

$${\bf w} = \begin{bmatrix}w_0\\w_1\\\vdots\\w_Q\end{bmatrix} \in \mathbb{R}^{Q+1} \qquad\qquad {\bf x}^{(n)} = \begin{bmatrix}\vphantom{1}\\x_1\\\vdots\\x_Q\end{bmatrix} \in \mathbb{R}^{Q} \qquad\qquad y^{(n)}\in\mathbb{R}$$

with the convention $x_0^{(n)}=1$.

Hint: This computation can be vectorized as follows.

• The vectors ${\bf x}^{(n)}$ are stacked in a matrix $X\in\mathbb{R}^{N\times Q}$, whereas the scalars $y^{(n)}$ are stacked in a vector ${\bf y}\in\mathbb{R}^N$:

$$X = \begin{bmatrix} \_\!\_\; { {\bf x}^{(1)}}^\top \_\!\_ \\ \vdots\\ \_\!\_\; { {\bf x}^{(N)}}^\top \_\!\_ \\ \end{bmatrix} \qquad\qquad {\bf y} = \begin{bmatrix} {y^{(1)}}^\top \\ \vdots\\ {y^{(N)}}^\top \end{bmatrix}.$$

• The products $z^{(n)} = {\bf w}^\top{\bf x}^{(n)}$, for every index $n$, are computed by multiplying $X$ by ${\bf w}$:

$${\bf z} = X{\bf w} = \begin{bmatrix} {\bf w}^\top{\bf x}^{(1)}\\ \vdots\\ {\bf w}^\top{\bf x}^{(N)} \end{bmatrix}.$$

• The distance $J$ is now equal to the squared norm of the difference between ${\bf z}$ and ${\bf y}$:

$$J = \|{\bf z} - {\bf y}\|^2 = \sum_{n=1}^{N} \big(z^{(n)}-y^{(n)}\big)^2.$$

Note hovewer that the shapes of X and w don't align for a matrix-vector product. To get around this, you can proceed as follows:

• Slice w so as to extract the elements w[1], ..., w[Q].
• Compute the product between X and the above elements.
• Add w[0] to the final result.

Quiz 3.7¶

Compute the pairwise distance between the rows of two matrices.

$$X = \begin{bmatrix} \_\_\,x_1\_\_ \\ \_\_\,x_2\_\_ \\ \vdots \\ \_\_\,x_N\_\_ \\ \end{bmatrix} \qquad\qquad Y = \begin{bmatrix} \_\_\,y_1\_\_ \\ \_\_\,y_2\_\_ \\ \vdots \\ \_\_\,y_K\_\_ \\ \end{bmatrix} \qquad\qquad \operatorname{dist}(X,Y) = \begin{bmatrix} ||x_1 - y_1|| & ||x_1 - y_2|| & \dots & ||x_1 - y_K|| \\ ||x_2 - y_1|| & ||x_2 - y_2|| & \dots & ||x_2 - y_K|| \\ \vdots & \vdots & \ddots & \vdots \\ ||x_N - y_1|| & ||x_N - y_2|| & \dots & ||x_N - y_K|| \\ \end{bmatrix}$$

Hint: It is possible to compute the differences X[i] - Y[j] via broadcasting. Here is how to do so.

• Reshape the matrix X to size (N,1,M).

• Reshape the matrix Y to size (1,K,M).

• The reshaped arrays now align for broadcasting.

Remember: You can use the None operator to insert an axis of length 1.

• The resulting array D is such that D[i,j] holds the vector X[i] - Y[j].

• You can use the function np.linalg.norm(..., axis=...) to compute the norm along a given axis.

Quiz 3.8¶

The Game of Life is a grid of square cells that can be in one of two possible states: live or dead.

The player creates an initial configuration of live cells and observes how they evolve. Every cell interacts with its 8 neighbours (the cells horizontally, vertically, or diagonally adjacent). At each step in time, the following transitions occur.

• Underpopulation: Any live cell with fewer than two live neighbours dies.

• Overcrowding: Any live cell with more than three live neighbours dies.

• Stability: Any live cell with two or three live neighbours lives unchanged to the next generation.

• Rebirth: Any dead cell with exactly three live neighbours becomes a live cell.

The initial pattern constitutes the 'seed' of the system. The first generation is created by applying the above rules simultaneously to every cell in the seed. Births and deaths happen simultaneously. The rules continue to be applied repeatedly to create further generations.

The Game of Life can be implemented by a matrix whose elements represent the single cells:

• 0 means the cell is dead,
• 1 means the cell is alive.

board = [[0,0,0,0,0,0],
         [0,0,0,1,0,0],
         [0,1,0,1,0,0],
         [0,0,1,1,0,0],
         [0,0,0,0,0,0],
         [0,0,0,0,0,0]]

The cells evolve through a for-loop which involves two operations at each iteration:

• counting the neighbors,
• applying the evolution rules.

Here is how the main function looks like.

def game_of_life(board, steps):
    for i in range(steps):
        count = neighbor_counting(board)
        board = evolution_rules(board, count)    
    return board

We provide you with the function neighbor_counting. Your job is to implement evolution_rules.

Implement a function that applies the evolution rules of the Game of Life (see the description above).

Hint: Use advanced indexing to avoid loops!

• Translate the evolution rules to boolean conditions,
• Use the boolean masks to set the new values.

Bonus :-)¶

Congratulations! You made it to the end. As a reward, sit back and watch The Game of Life.

Run the following cells to play the animation. The creation process may take a while.

Reaction and diffusion of chemical species can produce a variety of patterns, reminiscent of those often seen in nature. The code below implements a more advanced version of The Game of Life, based on the Gray-Scott equations. Just execute the cell, no further action is required from you.

The function chemical_reaction() allows you to simulate a chemical reaction, much like in The Game of Life.

Execute the next cell and enjoy the amination!

• There are different reaction types that you can choose from. Look inside the function chemical_reaction() for the complete list.

• You can go back, change the parameter steps or mode, and run again the simulation.